/*
 * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.hsc.lock.annotation;

import com.hsc.lock.interceptor.AbstractFallbackLockOperationSource;
import com.hsc.lock.interceptor.OperationSource;
import com.hsc.lock.interceptor.ReplayLockOperation;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;

import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.*;

/**
 * Implementation of the {@link OperationSource
 * CacheOperationSource} interface for working with caching metadata in annotation format.
 *
 * <p>This class reads Spring's {@link Cacheable}, {@link CachePut} and {@link CacheEvict}
 * annotations and exposes corresponding caching operation definition to Spring's cache
 * infrastructure. This class may also serve as base class for a custom
 * {@code CacheOperationSource}.
 *
 * @author Costin Leau
 * @author Juergen Hoeller
 * @author Stephane Nicoll
 * @since 3.1
 */
@SuppressWarnings("serial")
public class  AnnotationLockOperationSource extends AbstractFallbackLockOperationSource implements Serializable {

    private final boolean publicMethodsOnly;

    private final Set<LockAnnotationParser> annotationParsers;


    /**
     * Create a default AnnotationCacheOperationSource, supporting public methods
     * that carry the {@code Cacheable} and {@code CacheEvict} annotations.
     */
    public AnnotationLockOperationSource() {
        this(true);
    }

    /**
     * Create a default {@code AnnotationCacheOperationSource}, supporting public methods
     * that carry the {@code Cacheable} and {@code CacheEvict} annotations.
     *
     * @param publicMethodsOnly whether to support only annotated public methods
     *                          typically for use with proxy-based AOP), or protected/private methods as well
     *                          (typically used with AspectJ class weaving)
     */
    public AnnotationLockOperationSource(boolean publicMethodsOnly) {
        this.publicMethodsOnly = publicMethodsOnly;
        this.annotationParsers = Collections.singleton(new SpringCacheAnnotationParser());
    }

    /**
     * Create a custom AnnotationCacheOperationSource.
     *
     * @param annotationParser the CacheAnnotationParser to use
     */
    public AnnotationLockOperationSource(LockAnnotationParser annotationParser) {
        this.publicMethodsOnly = true;
        Assert.notNull(annotationParser, "CacheAnnotationParser must not be null");
        this.annotationParsers = Collections.singleton(annotationParser);
    }

    /**
     * Create a custom AnnotationCacheOperationSource.
     *
     * @param annotationParsers the CacheAnnotationParser to use
     */
    public AnnotationLockOperationSource(LockAnnotationParser... annotationParsers) {
        this.publicMethodsOnly = true;
        Assert.notEmpty(annotationParsers, "At least one CacheAnnotationParser needs to be specified");
        this.annotationParsers = new LinkedHashSet<>(Arrays.asList(annotationParsers));
    }

    /**
     * Create a custom AnnotationCacheOperationSource.
     *
     * @param annotationParsers the CacheAnnotationParser to use
     */
    public AnnotationLockOperationSource(Set<LockAnnotationParser> annotationParsers) {
        this.publicMethodsOnly = true;
        Assert.notEmpty(annotationParsers, "At least one CacheAnnotationParser needs to be specified");
        this.annotationParsers = annotationParsers;
    }


    @Override
    public boolean isCandidateClass(Class<?> targetClass) {
        for (LockAnnotationParser parser : this.annotationParsers) {
            if (parser.isCandidateClass(targetClass)) {
                return true;
            }
        }
        return false;
    }

    @Override
    @Nullable
    protected Collection<ReplayLockOperation> findCacheOperations(Class<?> clazz) {
        return determineCacheOperations(parser -> parser.parseCacheAnnotations(clazz));
    }

    @Override
    @Nullable
    protected Collection<ReplayLockOperation> findCacheOperations(Method method) {
        return determineCacheOperations(parser -> parser.parseCacheAnnotations(method));
    }

    /**
     * Determine the cache operation(s) for the given {@link CacheOperationProvider}.
     * <p>This implementation delegates to configured
     * {@link LockAnnotationParser CacheAnnotationParsers}
     * for parsing known annotations into Spring's metadata attribute class.
     * <p>Can be overridden to support custom annotations that carry caching metadata.
     *
     * @param provider the cache operation provider to use
     * @return the configured caching operations, or {@code null} if none found
     */
    @Nullable
    protected Collection<ReplayLockOperation> determineCacheOperations(CacheOperationProvider provider) {
        Collection<ReplayLockOperation> ops = null;
        for (LockAnnotationParser parser : this.annotationParsers) {
            Collection<ReplayLockOperation> annOps = provider.getCacheOperations(parser);
            if (annOps != null) {
                if (ops == null) {
                    ops = annOps;
                } else {
                    Collection<ReplayLockOperation> combined = new ArrayList<>(ops.size() + annOps.size());
                    combined.addAll(ops);
                    combined.addAll(annOps);
                    ops = combined;
                }
            }
        }
        return ops;
    }

    /**
     * By default, only public methods can be made cacheable.
     */
    @Override
    protected boolean allowPublicMethodsOnly() {
        return this.publicMethodsOnly;
    }


    @Override
    public boolean equals(@Nullable Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof AnnotationLockOperationSource)) {
            return false;
        }
        AnnotationLockOperationSource otherCos = (AnnotationLockOperationSource) other;
        return (this.annotationParsers.equals(otherCos.annotationParsers) &&
                this.publicMethodsOnly == otherCos.publicMethodsOnly);
    }

    @Override
    public int hashCode() {
        return this.annotationParsers.hashCode();
    }


    /**
     * Callback interface providing {@link ReplayLockOperation} instance(s) based on
     * a given {@link LockAnnotationParser}.
     */
    @FunctionalInterface
    protected interface CacheOperationProvider {

        /**
         * Return the {@link ReplayLockOperation} instance(s) provided by the specified parser.
         *
         * @param parser the parser to use
         * @return the cache operations, or {@code null} if none found
         */
        @Nullable
        Collection<ReplayLockOperation> getCacheOperations(LockAnnotationParser parser);
    }

}
